// 数据同步相关的actions
export default {
  // 开始同步
  async startSync({ commit, dispatch }) {
    try {
      commit('SET_LOADING', true)
      dispatch('setLoading', true)
      
      // 调用API开始同步
      const response = await this.app.$api.sync.startSync()
      
      // 设置同步状态
      commit('SET_IS_SYNCING', true)
      commit('SET_PROGRESS', 0)
      
      // 开始同步提示
      this.app.$message.success('数据同步已开始')
      
      // 开始轮询同步状态
      this.syncPollingInterval = setInterval(() => {
        dispatch('fetchSyncStatus')
      }, 3000) // 每3秒查询一次同步状态
    } catch (error) {
      console.error('Failed to start sync:', error)
      commit('SET_ERROR', error.message)
      this.app.$message.error('数据同步启动失败')
    } finally {
      commit('SET_LOADING', false)
      dispatch('setLoading', false)
    }
  },
  
  // 停止同步
  async stopSync({ commit, dispatch }) {
    try {
      commit('SET_LOADING', true)
      dispatch('setLoading', true)
      
      // 调用API停止同步
      await this.app.$api.sync.stopSync()
      
      // 清除轮询
      if (this.syncPollingInterval) {
        clearInterval(this.syncPollingInterval)
        this.syncPollingInterval = null
      }
      
      // 设置同步状态
      commit('SET_IS_SYNCING', false)
      commit('CLEAR_SYNC_STATUS')
      
      // 停止同步提示
      this.app.$message.success('数据同步已停止')
      
      // 重新获取同步历史
      await dispatch('fetchSyncHistory')
    } catch (error) {
      console.error('Failed to stop sync:', error)
      commit('SET_ERROR', error.message)
      this.app.$message.error('数据同步停止失败')
    } finally {
      commit('SET_LOADING', false)
      dispatch('setLoading', false)
    }
  },
  
  // 获取同步状态
  async fetchSyncStatus({ commit }) {
    try {
      // 调用API获取同步状态
      const response = await this.app.$api.sync.getSyncStatus()
      
      // 设置同步状态
      commit('SET_SYNC_STATUS', response.data)
      
      // 设置同步进度
      if (response.data && response.data.progress !== undefined) {
        commit('SET_PROGRESS', response.data.progress)
      }
      
      // 如果同步已完成，清除轮询并更新最后同步时间
      if (response.data && response.data.status === 'completed') {
        if (this.syncPollingInterval) {
          clearInterval(this.syncPollingInterval)
          this.syncPollingInterval = null
        }
        commit('SET_IS_SYNCING', false)
        commit('SET_LAST_SYNC_TIME', new Date())
        this.app.$message.success('数据同步已完成')
      }
      
      // 如果同步失败，清除轮询
      if (response.data && response.data.status === 'failed') {
        if (this.syncPollingInterval) {
          clearInterval(this.syncPollingInterval)
          this.syncPollingInterval = null
        }
        commit('SET_IS_SYNCING', false)
        this.app.$message.error('数据同步失败')
      }
    } catch (error) {
      console.error('Failed to fetch sync status:', error)
      commit('SET_ERROR', error.message)
    }
  },
  
  // 获取同步历史
  async fetchSyncHistory({ commit, dispatch }) {
    try {
      commit('SET_LOADING', true)
      dispatch('setLoading', true)
      
      // 调用API获取同步历史
      const response = await this.app.$api.sync.getSyncHistory()
      
      // 设置同步历史
      commit('SET_SYNC_HISTORY', response.data || [])
      
      // 更新最后同步时间
      if (response.data && response.data.length > 0) {
        const latestSync = response.data[0]
        if (latestSync.endTime) {
          commit('SET_LAST_SYNC_TIME', new Date(latestSync.endTime))
        }
      }
    } catch (error) {
      console.error('Failed to fetch sync history:', error)
      commit('SET_ERROR', error.message)
      this.app.$message.error('获取同步历史失败')
    } finally {
      commit('SET_LOADING', false)
      dispatch('setLoading', false)
    }
  },
  
  // 手动更新同步进度
  updateSyncProgress({ commit }, progress) {
    commit('SET_PROGRESS', progress)
  },
  
  // 清空同步状态
  clearSyncStatus({ commit }) {
    commit('CLEAR_SYNC_STATUS')
  },
  
  // 清空同步历史
  clearSyncHistory({ commit }) {
    commit('CLEAR_SYNC_HISTORY')
  },
  
  // 重置同步模块状态
  resetSyncState({ commit }) {
    commit('RESET_SYNC_STATE')
    
    // 清除轮询
    if (this.syncPollingInterval) {
      clearInterval(this.syncPollingInterval)
      this.syncPollingInterval = null
    }
  },
  
  // 清理函数，在组件卸载时调用
  cleanup() {
    if (this.syncPollingInterval) {
      clearInterval(this.syncPollingInterval)
      this.syncPollingInterval = null
    }
  }
}